home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Python 1.3.3 / Python 133 SRC / Mac / Modules / menu / Menumodule.c < prev    next >
Text File  |  1996-04-12  |  24KB  |  1,049 lines
  1.  
  2. /* ========================== Module Menu =========================== */
  3.  
  4. #include "Python.h"
  5.  
  6.  
  7.  
  8. #define SystemSevenOrLater 1
  9.  
  10. #include "macglue.h"
  11. #include <Memory.h>
  12. #include <Dialogs.h>
  13. #include <Menus.h>
  14. #include <Controls.h>
  15.  
  16. extern PyObject *ResObj_New(Handle);
  17. extern int ResObj_Convert(PyObject *, Handle *);
  18. extern PyObject *OptResObj_New(Handle);
  19. extern int OptResObj_Convert(PyObject *, Handle *);
  20.  
  21. extern PyObject *WinObj_New(WindowPtr);
  22. extern int WinObj_Convert(PyObject *, WindowPtr *);
  23. extern PyTypeObject Window_Type;
  24. #define WinObj_Check(x) ((x)->ob_type == &Window_Type)
  25.  
  26. extern PyObject *DlgObj_New(DialogPtr);
  27. extern int DlgObj_Convert(PyObject *, DialogPtr *);
  28. extern PyTypeObject Dialog_Type;
  29. #define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
  30.  
  31. extern PyObject *MenuObj_New(MenuHandle);
  32. extern int MenuObj_Convert(PyObject *, MenuHandle *);
  33.  
  34. extern PyObject *CtlObj_New(ControlHandle);
  35. extern int CtlObj_Convert(PyObject *, ControlHandle *);
  36.  
  37. extern PyObject *GrafObj_New(GrafPtr);
  38. extern int GrafObj_Convert(PyObject *, GrafPtr *);
  39.  
  40. extern PyObject *BMObj_New(BitMapPtr);
  41. extern int BMObj_Convert(PyObject *, BitMapPtr *);
  42.  
  43. extern PyObject *PMObj_New(PixMapHandle);
  44. extern int PMObj_Convert(PyObject *, PixMapHandle *);
  45.  
  46. extern PyObject *WinObj_WhichWindow(WindowPtr);
  47.  
  48. #include <Devices.h> /* Defines OpenDeskAcc in universal headers */
  49. #include <Desk.h> /* Defines OpenDeskAcc in old headers */
  50. #include <Menus.h>
  51.  
  52. #define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
  53.  
  54. static PyObject *Menu_Error;
  55.  
  56. /* ------------------------ Object type Menu ------------------------ */
  57.  
  58. PyTypeObject Menu_Type;
  59.  
  60. #define MenuObj_Check(x) ((x)->ob_type == &Menu_Type)
  61.  
  62. typedef struct MenuObject {
  63.     PyObject_HEAD
  64.     MenuHandle ob_itself;
  65. } MenuObject;
  66.  
  67. PyObject *MenuObj_New(itself)
  68.     MenuHandle itself;
  69. {
  70.     MenuObject *it;
  71.     it = PyObject_NEW(MenuObject, &Menu_Type);
  72.     if (it == NULL) return NULL;
  73.     it->ob_itself = itself;
  74.     return (PyObject *)it;
  75. }
  76. MenuObj_Convert(v, p_itself)
  77.     PyObject *v;
  78.     MenuHandle *p_itself;
  79. {
  80.     if (!MenuObj_Check(v))
  81.     {
  82.         PyErr_SetString(PyExc_TypeError, "Menu required");
  83.         return 0;
  84.     }
  85.     *p_itself = ((MenuObject *)v)->ob_itself;
  86.     return 1;
  87. }
  88.  
  89. static void MenuObj_dealloc(self)
  90.     MenuObject *self;
  91. {
  92.     /* Cleanup of self->ob_itself goes here */
  93.     PyMem_DEL(self);
  94. }
  95.  
  96. static PyObject *MenuObj_DisposeMenu(_self, _args)
  97.     MenuObject *_self;
  98.     PyObject *_args;
  99. {
  100.     PyObject *_res = NULL;
  101.     if (!PyArg_ParseTuple(_args, ""))
  102.         return NULL;
  103.     DisposeMenu(_self->ob_itself);
  104.     Py_INCREF(Py_None);
  105.     _res = Py_None;
  106.     return _res;
  107. }
  108.  
  109. static PyObject *MenuObj_AppendMenu(_self, _args)
  110.     MenuObject *_self;
  111.     PyObject *_args;
  112. {
  113.     PyObject *_res = NULL;
  114.     Str255 data;
  115.     if (!PyArg_ParseTuple(_args, "O&",
  116.                           PyMac_GetStr255, data))
  117.         return NULL;
  118.     AppendMenu(_self->ob_itself,
  119.                data);
  120.     Py_INCREF(Py_None);
  121.     _res = Py_None;
  122.     return _res;
  123. }
  124.  
  125. static PyObject *MenuObj_AppendResMenu(_self, _args)
  126.     MenuObject *_self;
  127.     PyObject *_args;
  128. {
  129.     PyObject *_res = NULL;
  130.     ResType theType;
  131.     if (!PyArg_ParseTuple(_args, "O&",
  132.                           PyMac_GetOSType, &theType))
  133.         return NULL;
  134.     AppendResMenu(_self->ob_itself,
  135.                   theType);
  136.     Py_INCREF(Py_None);
  137.     _res = Py_None;
  138.     return _res;
  139. }
  140.  
  141. static PyObject *MenuObj_InsertResMenu(_self, _args)
  142.     MenuObject *_self;
  143.     PyObject *_args;
  144. {
  145.     PyObject *_res = NULL;
  146.     ResType theType;
  147.     short afterItem;
  148.     if (!PyArg_ParseTuple(_args, "O&h",
  149.                           PyMac_GetOSType, &theType,
  150.                           &afterItem))
  151.         return NULL;
  152.     InsertResMenu(_self->ob_itself,
  153.                   theType,
  154.                   afterItem);
  155.     Py_INCREF(Py_None);
  156.     _res = Py_None;
  157.     return _res;
  158. }
  159.  
  160. static PyObject *MenuObj_InsertMenu(_self, _args)
  161.     MenuObject *_self;
  162.     PyObject *_args;
  163. {
  164.     PyObject *_res = NULL;
  165.     short beforeID;
  166.     if (!PyArg_ParseTuple(_args, "h",
  167.                           &beforeID))
  168.         return NULL;
  169.     InsertMenu(_self->ob_itself,
  170.                beforeID);
  171.     Py_INCREF(Py_None);
  172.     _res = Py_None;
  173.     return _res;
  174. }
  175.  
  176. static PyObject *MenuObj_InsertMenuItem(_self, _args)
  177.     MenuObject *_self;
  178.     PyObject *_args;
  179. {
  180.     PyObject *_res = NULL;
  181.     Str255 itemString;
  182.     short afterItem;
  183.     if (!PyArg_ParseTuple(_args, "O&h",
  184.                           PyMac_GetStr255, itemString,
  185.                           &afterItem))
  186.         return NULL;
  187.     InsertMenuItem(_self->ob_itself,
  188.                    itemString,
  189.                    afterItem);
  190.     Py_INCREF(Py_None);
  191.     _res = Py_None;
  192.     return _res;
  193. }
  194.  
  195. static PyObject *MenuObj_DeleteMenuItem(_self, _args)
  196.     MenuObject *_self;
  197.     PyObject *_args;
  198. {
  199.     PyObject *_res = NULL;
  200.     short item;
  201.     if (!PyArg_ParseTuple(_args, "h",
  202.                           &item))
  203.         return NULL;
  204.     DeleteMenuItem(_self->ob_itself,
  205.                    item);
  206.     Py_INCREF(Py_None);
  207.     _res = Py_None;
  208.     return _res;
  209. }
  210.  
  211. static PyObject *MenuObj_SetMenuItemText(_self, _args)
  212.     MenuObject *_self;
  213.     PyObject *_args;
  214. {
  215.     PyObject *_res = NULL;
  216.     short item;
  217.     Str255 itemString;
  218.     if (!PyArg_ParseTuple(_args, "hO&",
  219.                           &item,
  220.                           PyMac_GetStr255, itemString))
  221.         return NULL;
  222.     SetMenuItemText(_self->ob_itself,
  223.                     item,
  224.                     itemString);
  225.     Py_INCREF(Py_None);
  226.     _res = Py_None;
  227.     return _res;
  228. }
  229.  
  230. static PyObject *MenuObj_GetMenuItemText(_self, _args)
  231.     MenuObject *_self;
  232.     PyObject *_args;
  233. {
  234.     PyObject *_res = NULL;
  235.     short item;
  236.     Str255 itemString;
  237.     if (!PyArg_ParseTuple(_args, "h",
  238.                           &item))
  239.         return NULL;
  240.     GetMenuItemText(_self->ob_itself,
  241.                     item,
  242.                     itemString);
  243.     _res = Py_BuildValue("O&",
  244.                          PyMac_BuildStr255, itemString);
  245.     return _res;
  246. }
  247.  
  248. static PyObject *MenuObj_DisableItem(_self, _args)
  249.     MenuObject *_self;
  250.     PyObject *_args;
  251. {
  252.     PyObject *_res = NULL;
  253.     short item;
  254.     if (!PyArg_ParseTuple(_args, "h",
  255.                           &item))
  256.         return NULL;
  257.     DisableItem(_self->ob_itself,
  258.                 item);
  259.     Py_INCREF(Py_None);
  260.     _res = Py_None;
  261.     return _res;
  262. }
  263.  
  264. static PyObject *MenuObj_EnableItem(_self, _args)
  265.     MenuObject *_self;
  266.     PyObject *_args;
  267. {
  268.     PyObject *_res = NULL;
  269.     short item;
  270.     if (!PyArg_ParseTuple(_args, "h",
  271.                           &item))
  272.         return NULL;
  273.     EnableItem(_self->ob_itself,
  274.                item);
  275.     Py_INCREF(Py_None);
  276.     _res = Py_None;
  277.     return _res;
  278. }
  279.  
  280. static PyObject *MenuObj_CheckItem(_self, _args)
  281.     MenuObject *_self;
  282.     PyObject *_args;
  283. {
  284.     PyObject *_res = NULL;
  285.     short item;
  286.     Boolean checked;
  287.     if (!PyArg_ParseTuple(_args, "hb",
  288.                           &item,
  289.                           &checked))
  290.         return NULL;
  291.     CheckItem(_self->ob_itself,
  292.               item,
  293.               checked);
  294.     Py_INCREF(Py_None);
  295.     _res = Py_None;
  296.     return _res;
  297. }
  298.  
  299. static PyObject *MenuObj_SetItemMark(_self, _args)
  300.     MenuObject *_self;
  301.     PyObject *_args;
  302. {
  303.     PyObject *_res = NULL;
  304.     short item;
  305.     short markChar;
  306.     if (!PyArg_ParseTuple(_args, "hh",
  307.                           &item,
  308.                           &markChar))
  309.         return NULL;
  310.     SetItemMark(_self->ob_itself,
  311.                 item,
  312.                 markChar);
  313.     Py_INCREF(Py_None);
  314.     _res = Py_None;
  315.     return _res;
  316. }
  317.  
  318. static PyObject *MenuObj_GetItemMark(_self, _args)
  319.     MenuObject *_self;
  320.     PyObject *_args;
  321. {
  322.     PyObject *_res = NULL;
  323.     short item;
  324.     short markChar;
  325.     if (!PyArg_ParseTuple(_args, "h",
  326.                           &item))
  327.         return NULL;
  328.     GetItemMark(_self->ob_itself,
  329.                 item,
  330.                 &markChar);
  331.     _res = Py_BuildValue("h",
  332.                          markChar);
  333.     return _res;
  334. }
  335.  
  336. static PyObject *MenuObj_SetItemIcon(_self, _args)
  337.     MenuObject *_self;
  338.     PyObject *_args;
  339. {
  340.     PyObject *_res = NULL;
  341.     short item;
  342.     short iconIndex;
  343.     if (!PyArg_ParseTuple(_args, "hh",
  344.                           &item,
  345.                           &iconIndex))
  346.         return NULL;
  347.     SetItemIcon(_self->ob_itself,
  348.                 item,
  349.                 iconIndex);
  350.     Py_INCREF(Py_None);
  351.     _res = Py_None;
  352.     return _res;
  353. }
  354.  
  355. static PyObject *MenuObj_GetItemIcon(_self, _args)
  356.     MenuObject *_self;
  357.     PyObject *_args;
  358. {
  359.     PyObject *_res = NULL;
  360.     short item;
  361.     short iconIndex;
  362.     if (!PyArg_ParseTuple(_args, "h",
  363.                           &item))
  364.         return NULL;
  365.     GetItemIcon(_self->ob_itself,
  366.                 item,
  367.                 &iconIndex);
  368.     _res = Py_BuildValue("h",
  369.                          iconIndex);
  370.     return _res;
  371. }
  372.  
  373. static PyObject *MenuObj_SetItemStyle(_self, _args)
  374.     MenuObject *_self;
  375.     PyObject *_args;
  376. {
  377.     PyObject *_res = NULL;
  378.     short item;
  379.     short chStyle;
  380.     if (!PyArg_ParseTuple(_args, "hh",
  381.                           &item,
  382.                           &chStyle))
  383.         return NULL;
  384.     SetItemStyle(_self->ob_itself,
  385.                  item,
  386.                  chStyle);
  387.     Py_INCREF(Py_None);
  388.     _res = Py_None;
  389.     return _res;
  390. }
  391.  
  392. static PyObject *MenuObj_GetItemStyle(_self, _args)
  393.     MenuObject *_self;
  394.     PyObject *_args;
  395. {
  396.     PyObject *_res = NULL;
  397.     short item;
  398.     Style chStyle;
  399.     if (!PyArg_ParseTuple(_args, "h",
  400.                           &item))
  401.         return NULL;
  402.     GetItemStyle(_self->ob_itself,
  403.                  item,
  404.                  &chStyle);
  405.     _res = Py_BuildValue("b",
  406.                          chStyle);
  407.     return _res;
  408. }
  409.  
  410. static PyObject *MenuObj_CalcMenuSize(_self, _args)
  411.     MenuObject *_self;
  412.     PyObject *_args;
  413. {
  414.     PyObject *_res = NULL;
  415.     if (!PyArg_ParseTuple(_args, ""))
  416.         return NULL;
  417.     CalcMenuSize(_self->ob_itself);
  418.     Py_INCREF(Py_None);
  419.     _res = Py_None;
  420.     return _res;
  421. }
  422.  
  423. static PyObject *MenuObj_CountMItems(_self, _args)
  424.     MenuObject *_self;
  425.     PyObject *_args;
  426. {
  427.     PyObject *_res = NULL;
  428.     short _rv;
  429.     if (!PyArg_ParseTuple(_args, ""))
  430.         return NULL;
  431.     _rv = CountMItems(_self->ob_itself);
  432.     _res = Py_BuildValue("h",
  433.                          _rv);
  434.     return _res;
  435. }
  436.  
  437. static PyObject *MenuObj_GetItemCmd(_self, _args)
  438.     MenuObject *_self;
  439.     PyObject *_args;
  440. {
  441.     PyObject *_res = NULL;
  442.     short item;
  443.     short cmdChar;
  444.     if (!PyArg_ParseTuple(_args, "h",
  445.                           &item))
  446.         return NULL;
  447.     GetItemCmd(_self->ob_itself,
  448.                item,
  449.                &cmdChar);
  450.     _res = Py_BuildValue("h",
  451.                          cmdChar);
  452.     return _res;
  453. }
  454.  
  455. static PyObject *MenuObj_SetItemCmd(_self, _args)
  456.     MenuObject *_self;
  457.     PyObject *_args;
  458. {
  459.     PyObject *_res = NULL;
  460.     short item;
  461.     short cmdChar;
  462.     if (!PyArg_ParseTuple(_args, "hh",
  463.                           &item,
  464.                           &cmdChar))
  465.         return NULL;
  466.     SetItemCmd(_self->ob_itself,
  467.                item,
  468.                cmdChar);
  469.     Py_INCREF(Py_None);
  470.     _res = Py_None;
  471.     return _res;
  472. }
  473.  
  474. static PyObject *MenuObj_PopUpMenuSelect(_self, _args)
  475.     MenuObject *_self;
  476.     PyObject *_args;
  477. {
  478.     PyObject *_res = NULL;
  479.     long _rv;
  480.     short top;
  481.     short left;
  482.     short popUpItem;
  483.     if (!PyArg_ParseTuple(_args, "hhh",
  484.                           &top,
  485.                           &left,
  486.                           &popUpItem))
  487.         return NULL;
  488.     _rv = PopUpMenuSelect(_self->ob_itself,
  489.                           top,
  490.                           left,
  491.                           popUpItem);
  492.     _res = Py_BuildValue("l",
  493.                          _rv);
  494.     return _res;
  495. }
  496.  
  497. static PyObject *MenuObj_InsertFontResMenu(_self, _args)
  498.     MenuObject *_self;
  499.     PyObject *_args;
  500. {
  501.     PyObject *_res = NULL;
  502.     short afterItem;
  503.     short scriptFilter;
  504.     if (!PyArg_ParseTuple(_args, "hh",
  505.                           &afterItem,
  506.                           &scriptFilter))
  507.         return NULL;
  508.     InsertFontResMenu(_self->ob_itself,
  509.                       afterItem,
  510.                       scriptFilter);
  511.     Py_INCREF(Py_None);
  512.     _res = Py_None;
  513.     return _res;
  514. }
  515.  
  516. static PyObject *MenuObj_InsertIntlResMenu(_self, _args)
  517.     MenuObject *_self;
  518.     PyObject *_args;
  519. {
  520.     PyObject *_res = NULL;
  521.     ResType theType;
  522.     short afterItem;
  523.     short scriptFilter;
  524.     if (!PyArg_ParseTuple(_args, "O&hh",
  525.                           PyMac_GetOSType, &theType,
  526.                           &afterItem,
  527.                           &scriptFilter))
  528.         return NULL;
  529.     InsertIntlResMenu(_self->ob_itself,
  530.                       theType,
  531.                       afterItem,
  532.                       scriptFilter);
  533.     Py_INCREF(Py_None);
  534.     _res = Py_None;
  535.     return _res;
  536. }
  537.  
  538. static PyObject *MenuObj_as_Resource(_self, _args)
  539.     MenuObject *_self;
  540.     PyObject *_args;
  541. {
  542.     PyObject *_res = NULL;
  543.  
  544.     return ResObj_New((Handle)_self->ob_itself);
  545.  
  546. }
  547.  
  548. static PyMethodDef MenuObj_methods[] = {
  549.     {"DisposeMenu", (PyCFunction)MenuObj_DisposeMenu, 1,
  550.      "() -> None"},
  551.     {"AppendMenu", (PyCFunction)MenuObj_AppendMenu, 1,
  552.      "(Str255 data) -> None"},
  553.     {"AppendResMenu", (PyCFunction)MenuObj_AppendResMenu, 1,
  554.      "(ResType theType) -> None"},
  555.     {"InsertResMenu", (PyCFunction)MenuObj_InsertResMenu, 1,
  556.      "(ResType theType, short afterItem) -> None"},
  557.     {"InsertMenu", (PyCFunction)MenuObj_InsertMenu, 1,
  558.      "(short beforeID) -> None"},
  559.     {"InsertMenuItem", (PyCFunction)MenuObj_InsertMenuItem, 1,
  560.      "(Str255 itemString, short afterItem) -> None"},
  561.     {"DeleteMenuItem", (PyCFunction)MenuObj_DeleteMenuItem, 1,
  562.      "(short item) -> None"},
  563.     {"SetMenuItemText", (PyCFunction)MenuObj_SetMenuItemText, 1,
  564.      "(short item, Str255 itemString) -> None"},
  565.     {"GetMenuItemText", (PyCFunction)MenuObj_GetMenuItemText, 1,
  566.      "(short item) -> (Str255 itemString)"},
  567.     {"DisableItem", (PyCFunction)MenuObj_DisableItem, 1,
  568.      "(short item) -> None"},
  569.     {"EnableItem", (PyCFunction)MenuObj_EnableItem, 1,
  570.      "(short item) -> None"},
  571.     {"CheckItem", (PyCFunction)MenuObj_CheckItem, 1,
  572.      "(short item, Boolean checked) -> None"},
  573.     {"SetItemMark", (PyCFunction)MenuObj_SetItemMark, 1,
  574.      "(short item, short markChar) -> None"},
  575.     {"GetItemMark", (PyCFunction)MenuObj_GetItemMark, 1,
  576.      "(short item) -> (short markChar)"},
  577.     {"SetItemIcon", (PyCFunction)MenuObj_SetItemIcon, 1,
  578.      "(short item, short iconIndex) -> None"},
  579.     {"GetItemIcon", (PyCFunction)MenuObj_GetItemIcon, 1,
  580.      "(short item) -> (short iconIndex)"},
  581.     {"SetItemStyle", (PyCFunction)MenuObj_SetItemStyle, 1,
  582.      "(short item, short chStyle) -> None"},
  583.     {"GetItemStyle", (PyCFunction)MenuObj_GetItemStyle, 1,
  584.      "(short item) -> (Style chStyle)"},
  585.     {"CalcMenuSize", (PyCFunction)MenuObj_CalcMenuSize, 1,
  586.      "() -> None"},
  587.     {"CountMItems", (PyCFunction)MenuObj_CountMItems, 1,
  588.      "() -> (short _rv)"},
  589.     {"GetItemCmd", (PyCFunction)MenuObj_GetItemCmd, 1,
  590.      "(short item) -> (short cmdChar)"},
  591.     {"SetItemCmd", (PyCFunction)MenuObj_SetItemCmd, 1,
  592.      "(short item, short cmdChar) -> None"},
  593.     {"PopUpMenuSelect", (PyCFunction)MenuObj_PopUpMenuSelect, 1,
  594.      "(short top, short left, short popUpItem) -> (long _rv)"},
  595.     {"InsertFontResMenu", (PyCFunction)MenuObj_InsertFontResMenu, 1,
  596.      "(short afterItem, short scriptFilter) -> None"},
  597.     {"InsertIntlResMenu", (PyCFunction)MenuObj_InsertIntlResMenu, 1,
  598.      "(ResType theType, short afterItem, short scriptFilter) -> None"},
  599.     {"as_Resource", (PyCFunction)MenuObj_as_Resource, 1,
  600.      "Return this Menu as a Resource"},
  601.     {NULL, NULL, 0}
  602. };
  603.  
  604. PyMethodChain MenuObj_chain = { MenuObj_methods, NULL };
  605.  
  606. static PyObject *MenuObj_getattr(self, name)
  607.     MenuObject *self;
  608.     char *name;
  609. {
  610.     return Py_FindMethodInChain(&MenuObj_chain, (PyObject *)self, name);
  611. }
  612.  
  613. #define MenuObj_setattr NULL
  614.  
  615. PyTypeObject Menu_Type = {
  616.     PyObject_HEAD_INIT(&PyType_Type)
  617.     0, /*ob_size*/
  618.     "Menu", /*tp_name*/
  619.     sizeof(MenuObject), /*tp_basicsize*/
  620.     0, /*tp_itemsize*/
  621.     /* methods */
  622.     (destructor) MenuObj_dealloc, /*tp_dealloc*/
  623.     0, /*tp_print*/
  624.     (getattrfunc) MenuObj_getattr, /*tp_getattr*/
  625.     (setattrfunc) MenuObj_setattr, /*tp_setattr*/
  626. };
  627.  
  628. /* ---------------------- End object type Menu ---------------------- */
  629.  
  630.  
  631. static PyObject *Menu_GetMBarHeight(_self, _args)
  632.     PyObject *_self;
  633.     PyObject *_args;
  634. {
  635.     PyObject *_res = NULL;
  636.     short _rv;
  637.     if (!PyArg_ParseTuple(_args, ""))
  638.         return NULL;
  639.     _rv = GetMBarHeight();
  640.     _res = Py_BuildValue("h",
  641.                          _rv);
  642.     return _res;
  643. }
  644.  
  645. static PyObject *Menu_InitMenus(_self, _args)
  646.     PyObject *_self;
  647.     PyObject *_args;
  648. {
  649.     PyObject *_res = NULL;
  650.     if (!PyArg_ParseTuple(_args, ""))
  651.         return NULL;
  652.     InitMenus();
  653.     Py_INCREF(Py_None);
  654.     _res = Py_None;
  655.     return _res;
  656. }
  657.  
  658. static PyObject *Menu_NewMenu(_self, _args)
  659.     PyObject *_self;
  660.     PyObject *_args;
  661. {
  662.     PyObject *_res = NULL;
  663.     MenuHandle _rv;
  664.     short menuID;
  665.     Str255 menuTitle;
  666.     if (!PyArg_ParseTuple(_args, "hO&",
  667.                           &menuID,
  668.                           PyMac_GetStr255, menuTitle))
  669.         return NULL;
  670.     _rv = NewMenu(menuID,
  671.                   menuTitle);
  672.     _res = Py_BuildValue("O&",
  673.                          MenuObj_New, _rv);
  674.     return _res;
  675. }
  676.  
  677. static PyObject *Menu_GetMenu(_self, _args)
  678.     PyObject *_self;
  679.     PyObject *_args;
  680. {
  681.     PyObject *_res = NULL;
  682.     MenuHandle _rv;
  683.     short resourceID;
  684.     if (!PyArg_ParseTuple(_args, "h",
  685.                           &resourceID))
  686.         return NULL;
  687.     _rv = GetMenu(resourceID);
  688.     _res = Py_BuildValue("O&",
  689.                          MenuObj_New, _rv);
  690.     return _res;
  691. }
  692.  
  693. static PyObject *Menu_DrawMenuBar(_self, _args)
  694.     PyObject *_self;
  695.     PyObject *_args;
  696. {
  697.     PyObject *_res = NULL;
  698.     if (!PyArg_ParseTuple(_args, ""))
  699.         return NULL;
  700.     DrawMenuBar();
  701.     Py_INCREF(Py_None);
  702.     _res = Py_None;
  703.     return _res;
  704. }
  705.  
  706. static PyObject *Menu_InvalMenuBar(_self, _args)
  707.     PyObject *_self;
  708.     PyObject *_args;
  709. {
  710.     PyObject *_res = NULL;
  711.     if (!PyArg_ParseTuple(_args, ""))
  712.         return NULL;
  713.     InvalMenuBar();
  714.     Py_INCREF(Py_None);
  715.     _res = Py_None;
  716.     return _res;
  717. }
  718.  
  719. static PyObject *Menu_DeleteMenu(_self, _args)
  720.     PyObject *_self;
  721.     PyObject *_args;
  722. {
  723.     PyObject *_res = NULL;
  724.     short menuID;
  725.     if (!PyArg_ParseTuple(_args, "h",
  726.                           &menuID))
  727.         return NULL;
  728.     DeleteMenu(menuID);
  729.     Py_INCREF(Py_None);
  730.     _res = Py_None;
  731.     return _res;
  732. }
  733.  
  734. static PyObject *Menu_ClearMenuBar(_self, _args)
  735.     PyObject *_self;
  736.     PyObject *_args;
  737. {
  738.     PyObject *_res = NULL;
  739.     if (!PyArg_ParseTuple(_args, ""))
  740.         return NULL;
  741.     ClearMenuBar();
  742.     Py_INCREF(Py_None);
  743.     _res = Py_None;
  744.     return _res;
  745. }
  746.  
  747. static PyObject *Menu_GetNewMBar(_self, _args)
  748.     PyObject *_self;
  749.     PyObject *_args;
  750. {
  751.     PyObject *_res = NULL;
  752.     Handle _rv;
  753.     short menuBarID;
  754.     if (!PyArg_ParseTuple(_args, "h",
  755.                           &menuBarID))
  756.         return NULL;
  757.     _rv = GetNewMBar(menuBarID);
  758.     _res = Py_BuildValue("O&",
  759.                          ResObj_New, _rv);
  760.     return _res;
  761. }
  762.  
  763. static PyObject *Menu_GetMenuBar(_self, _args)
  764.     PyObject *_self;
  765.     PyObject *_args;
  766. {
  767.     PyObject *_res = NULL;
  768.     Handle _rv;
  769.     if (!PyArg_ParseTuple(_args, ""))
  770.         return NULL;
  771.     _rv = GetMenuBar();
  772.     _res = Py_BuildValue("O&",
  773.                          ResObj_New, _rv);
  774.     return _res;
  775. }
  776.  
  777. static PyObject *Menu_SetMenuBar(_self, _args)
  778.     PyObject *_self;
  779.     PyObject *_args;
  780. {
  781.     PyObject *_res = NULL;
  782.     Handle menuList;
  783.     if (!PyArg_ParseTuple(_args, "O&",
  784.                           ResObj_Convert, &menuList))
  785.         return NULL;
  786.     SetMenuBar(menuList);
  787.     Py_INCREF(Py_None);
  788.     _res = Py_None;
  789.     return _res;
  790. }
  791.  
  792. static PyObject *Menu_MenuKey(_self, _args)
  793.     PyObject *_self;
  794.     PyObject *_args;
  795. {
  796.     PyObject *_res = NULL;
  797.     long _rv;
  798.     short ch;
  799.     if (!PyArg_ParseTuple(_args, "h",
  800.                           &ch))
  801.         return NULL;
  802.     _rv = MenuKey(ch);
  803.     _res = Py_BuildValue("l",
  804.                          _rv);
  805.     return _res;
  806. }
  807.  
  808. static PyObject *Menu_HiliteMenu(_self, _args)
  809.     PyObject *_self;
  810.     PyObject *_args;
  811. {
  812.     PyObject *_res = NULL;
  813.     short menuID;
  814.     if (!PyArg_ParseTuple(_args, "h",
  815.                           &menuID))
  816.         return NULL;
  817.     HiliteMenu(menuID);
  818.     Py_INCREF(Py_None);
  819.     _res = Py_None;
  820.     return _res;
  821. }
  822.  
  823. static PyObject *Menu_GetMenuHandle(_self, _args)
  824.     PyObject *_self;
  825.     PyObject *_args;
  826. {
  827.     PyObject *_res = NULL;
  828.     MenuHandle _rv;
  829.     short menuID;
  830.     if (!PyArg_ParseTuple(_args, "h",
  831.                           &menuID))
  832.         return NULL;
  833.     _rv = GetMenuHandle(menuID);
  834.     _res = Py_BuildValue("O&",
  835.                          MenuObj_New, _rv);
  836.     return _res;
  837. }
  838.  
  839. static PyObject *Menu_FlashMenuBar(_self, _args)
  840.     PyObject *_self;
  841.     PyObject *_args;
  842. {
  843.     PyObject *_res = NULL;
  844.     short menuID;
  845.     if (!PyArg_ParseTuple(_args, "h",
  846.                           &menuID))
  847.         return NULL;
  848.     FlashMenuBar(menuID);
  849.     Py_INCREF(Py_None);
  850.     _res = Py_None;
  851.     return _res;
  852. }
  853.  
  854. static PyObject *Menu_SetMenuFlash(_self, _args)
  855.     PyObject *_self;
  856.     PyObject *_args;
  857. {
  858.     PyObject *_res = NULL;
  859.     short count;
  860.     if (!PyArg_ParseTuple(_args, "h",
  861.                           &count))
  862.         return NULL;
  863.     SetMenuFlash(count);
  864.     Py_INCREF(Py_None);
  865.     _res = Py_None;
  866.     return _res;
  867. }
  868.  
  869. static PyObject *Menu_MenuSelect(_self, _args)
  870.     PyObject *_self;
  871.     PyObject *_args;
  872. {
  873.     PyObject *_res = NULL;
  874.     long _rv;
  875.     Point startPt;
  876.     if (!PyArg_ParseTuple(_args, "O&",
  877.                           PyMac_GetPoint, &startPt))
  878.         return NULL;
  879.     _rv = MenuSelect(startPt);
  880.     _res = Py_BuildValue("l",
  881.                          _rv);
  882.     return _res;
  883. }
  884.  
  885. static PyObject *Menu_InitProcMenu(_self, _args)
  886.     PyObject *_self;
  887.     PyObject *_args;
  888. {
  889.     PyObject *_res = NULL;
  890.     short resID;
  891.     if (!PyArg_ParseTuple(_args, "h",
  892.                           &resID))
  893.         return NULL;
  894.     InitProcMenu(resID);
  895.     Py_INCREF(Py_None);
  896.     _res = Py_None;
  897.     return _res;
  898. }
  899.  
  900. static PyObject *Menu_MenuChoice(_self, _args)
  901.     PyObject *_self;
  902.     PyObject *_args;
  903. {
  904.     PyObject *_res = NULL;
  905.     long _rv;
  906.     if (!PyArg_ParseTuple(_args, ""))
  907.         return NULL;
  908.     _rv = MenuChoice();
  909.     _res = Py_BuildValue("l",
  910.                          _rv);
  911.     return _res;
  912. }
  913.  
  914. static PyObject *Menu_DeleteMCEntries(_self, _args)
  915.     PyObject *_self;
  916.     PyObject *_args;
  917. {
  918.     PyObject *_res = NULL;
  919.     short menuID;
  920.     short menuItem;
  921.     if (!PyArg_ParseTuple(_args, "hh",
  922.                           &menuID,
  923.                           &menuItem))
  924.         return NULL;
  925.     DeleteMCEntries(menuID,
  926.                     menuItem);
  927.     Py_INCREF(Py_None);
  928.     _res = Py_None;
  929.     return _res;
  930. }
  931.  
  932. static PyObject *Menu_SystemEdit(_self, _args)
  933.     PyObject *_self;
  934.     PyObject *_args;
  935. {
  936.     PyObject *_res = NULL;
  937.     Boolean _rv;
  938.     short editCmd;
  939.     if (!PyArg_ParseTuple(_args, "h",
  940.                           &editCmd))
  941.         return NULL;
  942.     _rv = SystemEdit(editCmd);
  943.     _res = Py_BuildValue("b",
  944.                          _rv);
  945.     return _res;
  946. }
  947.  
  948. static PyObject *Menu_SystemMenu(_self, _args)
  949.     PyObject *_self;
  950.     PyObject *_args;
  951. {
  952.     PyObject *_res = NULL;
  953.     long menuResult;
  954.     if (!PyArg_ParseTuple(_args, "l",
  955.                           &menuResult))
  956.         return NULL;
  957.     SystemMenu(menuResult);
  958.     Py_INCREF(Py_None);
  959.     _res = Py_None;
  960.     return _res;
  961. }
  962.  
  963. static PyObject *Menu_OpenDeskAcc(_self, _args)
  964.     PyObject *_self;
  965.     PyObject *_args;
  966. {
  967.     PyObject *_res = NULL;
  968.     Str255 name;
  969.     if (!PyArg_ParseTuple(_args, "O&",
  970.                           PyMac_GetStr255, name))
  971.         return NULL;
  972.     OpenDeskAcc(name);
  973.     Py_INCREF(Py_None);
  974.     _res = Py_None;
  975.     return _res;
  976. }
  977.  
  978. static PyMethodDef Menu_methods[] = {
  979.     {"GetMBarHeight", (PyCFunction)Menu_GetMBarHeight, 1,
  980.      "() -> (short _rv)"},
  981.     {"InitMenus", (PyCFunction)Menu_InitMenus, 1,
  982.      "() -> None"},
  983.     {"NewMenu", (PyCFunction)Menu_NewMenu, 1,
  984.      "(short menuID, Str255 menuTitle) -> (MenuHandle _rv)"},
  985.     {"GetMenu", (PyCFunction)Menu_GetMenu, 1,
  986.      "(short resourceID) -> (MenuHandle _rv)"},
  987.     {"DrawMenuBar", (PyCFunction)Menu_DrawMenuBar, 1,
  988.      "() -> None"},
  989.     {"InvalMenuBar", (PyCFunction)Menu_InvalMenuBar, 1,
  990.      "() -> None"},
  991.     {"DeleteMenu", (PyCFunction)Menu_DeleteMenu, 1,
  992.      "(short menuID) -> None"},
  993.     {"ClearMenuBar", (PyCFunction)Menu_ClearMenuBar, 1,
  994.      "() -> None"},
  995.     {"GetNewMBar", (PyCFunction)Menu_GetNewMBar, 1,
  996.      "(short menuBarID) -> (Handle _rv)"},
  997.     {"GetMenuBar", (PyCFunction)Menu_GetMenuBar, 1,
  998.      "() -> (Handle _rv)"},
  999.     {"SetMenuBar", (PyCFunction)Menu_SetMenuBar, 1,
  1000.      "(Handle menuList) -> None"},
  1001.     {"MenuKey", (PyCFunction)Menu_MenuKey, 1,
  1002.      "(short ch) -> (long _rv)"},
  1003.     {"HiliteMenu", (PyCFunction)Menu_HiliteMenu, 1,
  1004.      "(short menuID) -> None"},
  1005.     {"GetMenuHandle", (PyCFunction)Menu_GetMenuHandle, 1,
  1006.      "(short menuID) -> (MenuHandle _rv)"},
  1007.     {"FlashMenuBar", (PyCFunction)Menu_FlashMenuBar, 1,
  1008.      "(short menuID) -> None"},
  1009.     {"SetMenuFlash", (PyCFunction)Menu_SetMenuFlash, 1,
  1010.      "(short count) -> None"},
  1011.     {"MenuSelect", (PyCFunction)Menu_MenuSelect, 1,
  1012.      "(Point startPt) -> (long _rv)"},
  1013.     {"InitProcMenu", (PyCFunction)Menu_InitProcMenu, 1,
  1014.      "(short resID) -> None"},
  1015.     {"MenuChoice", (PyCFunction)Menu_MenuChoice, 1,
  1016.      "() -> (long _rv)"},
  1017.     {"DeleteMCEntries", (PyCFunction)Menu_DeleteMCEntries, 1,
  1018.      "(short menuID, short menuItem) -> None"},
  1019.     {"SystemEdit", (PyCFunction)Menu_SystemEdit, 1,
  1020.      "(short editCmd) -> (Boolean _rv)"},
  1021.     {"SystemMenu", (PyCFunction)Menu_SystemMenu, 1,
  1022.      "(long menuResult) -> None"},
  1023.     {"OpenDeskAcc", (PyCFunction)Menu_OpenDeskAcc, 1,
  1024.      "(Str255 name) -> None"},
  1025.     {NULL, NULL, 0}
  1026. };
  1027.  
  1028.  
  1029.  
  1030.  
  1031. void initMenu()
  1032. {
  1033.     PyObject *m;
  1034.     PyObject *d;
  1035.  
  1036.  
  1037.  
  1038.  
  1039.     m = Py_InitModule("Menu", Menu_methods);
  1040.     d = PyModule_GetDict(m);
  1041.     Menu_Error = PyMac_GetOSErrException();
  1042.     if (Menu_Error == NULL ||
  1043.         PyDict_SetItemString(d, "Error", Menu_Error) != 0)
  1044.         Py_FatalError("can't initialize Menu.Error");
  1045. }
  1046.  
  1047. /* ======================== End module Menu ========================= */
  1048.  
  1049.